﻿package work.lianbiao;

import java.io.File;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import jxl.Workbook;
import jxl.write.Label;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.biff.RowsExceededException;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.CharUtils;
import org.apache.log4j.Logger;

import com.h819.core.utils.file.excel.jxl.ExcelUtils;
import com.h819.util.db.MySQL;
import com.h819.util.db.Oracle_std;
import com.h819.util.db.Oracle_trs;
import com.h819.work.utils.StandardClassUtils;
import com.h819.work.utils.StandardCodeUtils;
import com.h819.core.utils.file.MyFileUtils;

public class FileUtil {

	/**
	 * @param args
	 */

	Logger log = Logger.getLogger(FileUtil.class);

	ExcelUtils eu = new ExcelUtils();

	int LIMIT_ROW = 100;

	// 类变量，仅用在 fileClassifyByFilename 函数
	// 设为类变量的目的是向外传值，否则递归的时候每次都覆盖计数器
	int fileAllNumber = 0;// 文件总数

	int directoryNumber = 0;// 文件夹总数

	int fileIsindustry25Number = 0;// 25个行业文件总数

	int delFileIsindustry25Number = 0;// 删除的25行业文件总数

	int fileIsNotindustry25Number = 0;// 非25个行业文件总数

	int delFileIsNotindustry25Number = 0;// 删除的非25个行业文件总数

	int copyFileIsNotindustry25Number = 0;// 拷贝的非25个行业文件总数

	int copyFileIsindustry25Number = 0;// 拷贝的25个行业文件总数

	// 应用updatelonelyPDFfile函数的前提是：
	// 1. 文本的名称和文本内的标准号一致(经过蓝标核对，能够保证),查询和比较均是从文本名称中解析出来的标准号.
	// 2. 对于更改了性质的标准，如 GB 123 -> GB/T 123 那么要有相应的两个对应名称的文本文件，虽然内容一致
	//
	// 这个函数用来:
	// 1. 查找有题录，有文本，但是没有对应关系的文件，按照文件名，查找对应的标准号，重新填写text_address项目
	// 2. 如果找不到相应的题录，说明是独立文件，拷贝到指定的文件夹
	//

	// excel 文件:
	// 第1行： 序号
	// 第2行：待校对的文件名称
	// 第3行：数据库中是否为null
	// 第4行：满足第三行，更新数据库 text_addree 的 str
	// 第5行：是否数据库中的 text_adress 和文本不一致时，数据库中的数值
	// 第6行：满足第5行，更新数据库 text_addree 的 str
	// 第8行: 根据第2行解析出来的的标准号
	public void updatelonelyPDFfile(String StdClass) {

		String pdfFileRoot = "F:/daijiaoyan/GB/";
		String excelFileRoot = "D:/updatelonelyPDFfile.xls";

		File pdfDirRoot = new File(pdfFileRoot);
		File excelDirRoot = new File(excelFileRoot);

		WritableWorkbook wwb = null;

		int sameCount = 0;

		// 建立文件
		try {
			// 首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象
			wwb = Workbook.createWorkbook(excelDirRoot);

		} catch (IOException e) {
			System.out.println("exception 0.");
			eu.closeWritableWorkbook(wwb);
			e.printStackTrace();
		}
		if (wwb == null)
			return;

		// 开始操作excel表
		// 创建一个可写入的工作表
		// Workbook的createSheet方法有两个参数，第一个是工作表的名称，第二个是工作表在工作薄中的位置
		WritableSheet ws = wwb.createSheet("sheet1", 0);

		Connection conn = null;
		Oracle_trs oracle = new Oracle_trs();
		conn = oracle.getConnection(conn);

		// int count = 0;
		// Map<String, Integer> mp = new TreeMap<String, Integer>();

		File[] listRootFiles = pdfDirRoot.listFiles();

		for (int i = 0; i < listRootFiles.length; i++) {

			if (listRootFiles[i].isDirectory())
				continue;

			// 得到指定目录的pdf文件的文件名,并解析成标准号
			// D://pdf/GB!T~123.pdf -> GB!T~123.pdf
			String pdfFileName = FilenameUtils.getName(listRootFiles[i]
					.getName());// 得到 GB!T~123.pdf
			String pdfStdcode = FilenameUtils.getBaseName(pdfFileName);// 得到
			// GB!T~123
			pdfStdcode = StringUtils.replace(pdfStdcode, "!", "/");// GB/T~123
			pdfStdcode = StringUtils.replace(pdfStdcode, "~", " ");// GB/T 123

			log.info("file name: " + pdfFileName);
			log.info("file name to standard code : " + pdfStdcode);

			// ===============================================
			// 记录到 excel
			// 下面开始添加单元格

			// 开始写入
			// 这里需要注意的是，在Excel中，第一个参数表示列，第二个表示行
			// 序号
			Label label0 = new Label(0, i, new java.lang.Integer(i + 1)
					.toString());

			Label label1 = new Label(1, i, pdfFileName);
			Label label2 = new Label(2, i, pdfStdcode);

			// 行数增加
			try {
				// 将生成的单元格添加到工作表中
				ws.addCell(label0);
				ws.addCell(label1);
				ws.addCell(label2);
			} catch (RowsExceededException e) {
				System.out.println("exception 2.");
				e.printStackTrace();
				// 发生异常关闭
				eu.closeWritableWorkbook(wwb);
			} catch (WriteException e) {
				System.out.println("exception 3.");
				e.printStackTrace();
				// 发生异常关闭
				eu.closeWritableWorkbook(wwb);
			}

			// ===============================================
			// 记录到 excel

			// ===============================================
			// 连接到 oracle 开始查询

			String oracleQueryStr = "select t.standard_code,t.text_address  from trstable t where t.standard_code='"
					+ pdfStdcode + "'";
			log.info("oracleQueryStr :" + oracleQueryStr);

			Statement stmt_oracleQuery = null;
			ResultSet rs_oracleQuery = null;

			try {

				stmt_oracleQuery = conn.createStatement();
				String oracle_stdcode = "";
				String oracle_std_text_address = "";

				if (stmt_oracleQuery.execute(oracleQueryStr)) {
					rs_oracleQuery = stmt_oracleQuery.getResultSet();

					while (rs_oracleQuery.next()) {

						oracle_stdcode = (String) rs_oracleQuery
								.getString("standard_code");

						log.info("text_address : "
								+ rs_oracleQuery.getString("text_address"));
						oracle_std_text_address = (String) rs_oracleQuery
								.getString("text_address");

					}
				}

				// Work/DB/DB11!T~311.1-2005.PDF
				oracle_std_text_address = StringUtils.substringAfterLast(
						oracle_std_text_address, "/");// 得到
				// DB11!T~311.1-2005.PDF
				// soraclestdtestadd =
				// FilenameUtils.getBaseName(soraclestdtestadd);// 得到
				// DB11!T~311.1-2005
				// soraclestdtestadd = StringUtils.replace(soraclestdtestadd,
				// "!", "/");// DB11/T~311.1-2005
				// soraclestdtestadd = StringUtils.replace(soraclestdtestadd,
				// "~", " ");// DB11/T 311.1-2005

				// oracle 中标准号和解析出来的地址相同，不用出来，跳过
				if (oracle_stdcode.equals(oracle_std_text_address)) {
					sameCount++;
					log.info("oracle stdcode: " + oracle_stdcode);
					log.info("oracle_std_text_address: "
							+ oracle_std_text_address);
					// 记录到 excel
					Label label3 = new Label(3, i,
							"std_code and std_textadress is the same in oracle");

					// 行数增加
					try {
						// 将生成的单元格添加到工作表中
						ws.addCell(label3);
					} catch (RowsExceededException e) {
						System.out.println("exception 2.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					} catch (WriteException e) {
						System.out.println("exception 3.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					}
					continue;

				}

				// 如果根据解析处理的标准号，查询数据库无结果，并且记录
				if (oracle_stdcode == "") { // soraclestdcode 没有经过 while
					// 设定值，保留原来定义变量时候的数值

					// 记录到 excel
					Label label4 = new Label(4, i, "std_code not in oracle");

					// 行数增加
					try {
						// 将生成的单元格添加到工作表中
						ws.addCell(label4);
					} catch (RowsExceededException e) {
						System.out.println("exception 2.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					} catch (WriteException e) {
						System.out.println("exception 3.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					}

				}

				// text_adress 为空,更改 其值，并且记录
				if (oracle_std_text_address == null) {

					Statement stmt_update_null = null;
					String update_null = "update trstable set text_address="
							+ "'Work/" + StdClass + "/" + pdfFileName
							+ "' where standard_code='" + pdfStdcode + "'";
					log.info("upade: " + update_null);

					try {
						stmt_update_null = conn.createStatement();
						stmt_update_null.executeUpdate(update_null);
						log.info("executeUpdate succeed.");
						oracle.closeDB(stmt_update_null);
					} catch (SQLException ex) {
						log.info("exception in executeUpdate action.");
						ex.printStackTrace();
						oracle.closeDB(stmt_update_null);
					}

					// 记录到 excel
					Label label5 = new Label(5, i, "null");
					Label label6 = new Label(6, i, update_null);

					// 行数增加
					try {
						// 将生成的单元格添加到工作表中
						ws.addCell(label5);
						ws.addCell(label6);
					} catch (RowsExceededException e) {
						System.out.println("exception 2.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					} catch (WriteException e) {
						System.out.println("exception 3.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					}
				}

				// 找到 pdf 文件和数据库中text_address 不相同的记录 ，记录的 excel 中

				log.info("pdfFileName :" + pdfFileName);
				log.info("oracle_std_text_address:" + oracle_std_text_address);

				// 记录 text_adress 不为空，并且数据库中的文件名称和待比较的文件名称不一致

				if (oracle_std_text_address != null
						&& (!pdfFileName.equals(oracle_std_text_address))) {
					Statement stmt_update_notsame = null;
					String update_notsame = "update trstable set text_address="
							+ "'Work/" + StdClass + "/" + pdfFileName
							+ "' where standard_code='" + pdfStdcode + "'";
					log.info("upade: " + update_notsame);

					try {
						stmt_update_notsame = conn.createStatement();
						stmt_update_notsame.executeUpdate(update_notsame);
						log.info("executeUpdate succeed.");
						oracle.closeDB(stmt_update_notsame);
					} catch (SQLException ex) {
						log.info("exception in executeUpdate action.");
						ex.printStackTrace();
						oracle.closeDB(stmt_update_notsame);
					}

					Label label7 = new Label(7, i, oracle_std_text_address);
					Label label8 = new Label(8, i, update_notsame);

					// 行数增加
					try {
						// 将生成的单元格添加到工作表中
						ws.addCell(label7);
						ws.addCell(label8);
					} catch (RowsExceededException e) {
						System.out.println("exception 2.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					} catch (WriteException e) {
						System.out.println("exception 3.");
						e.printStackTrace();
						// 发生异常关闭
						eu.closeWritableWorkbook(wwb);
					}

				}

				log.info("query succeed.");
				oracle.closeDB(rs_oracleQuery, stmt_oracleQuery);

			} catch (SQLException ex) {
				log.info("exception in query action.");
				oracle.closeDB(rs_oracleQuery, stmt_oracleQuery, conn);
			}

		} // 开始第二个文件比对

		oracle.closeDB(conn);
		log.info("sameCount is: " + sameCount);

		// 从内存中写入文件中
		try {
			wwb.write();
			wwb.close();
		} catch (WriteException e) {
			// TODO Auto-generated catch block
			System.out.println("exception 4.");
			e.printStackTrace();
		} catch (IOException e) {
			System.out.println("exception 5.");
			e.printStackTrace();
		}
	}

	// 补充完善蓝标校对过后的题录信息
	// 校对过程中发现，标准分类有很多没有，还有其他的一些问题
	// 可以编程序完善的，就从程序完善
	public void updateJiaoduiTiLu() {

		// oracle_standard
		Connection conn_oracle = null;
		Oracle_trs oracle = new Oracle_trs();
		conn_oracle = oracle.getConnection(conn_oracle);

		Statement oracle_stmt_select = null;
		ResultSet oracle_rs_select = null;

		Statement oracle_stmt_update = null;

		int countUpdateNumber = 0;

		String oracleQueryStr = "select standard_code from s0903";

		// log.info("oracleQueryStr: " + oracleQueryStr);

		ArrayList<ArrayList<String>> classList = StandardClassUtils
				.getClassCode_GN2();
		ArrayList<String> haveNoClassList = new ArrayList<String>();

		String STANDARD_CODE = "";

		String classCode = "";
		String class_one_code = "";
		String class_two_code = "";
		String class_three_code = "";
		String class_four_code = "";
		String text_address = "";
		String fileName = "";

		// 开始从待完善的表中查询需要完善的题录信息
		try {

			// oracle_stmt = oracle_conn.createStatement();
			// 为了支持 oracle_rs.beforeFirst() 方法，createStatement 带了参数
			// 否则 oracle_stmt = oracle_conn.createStatement() 即可

			oracle_stmt_select = conn_oracle.createStatement(
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);

			oracle_stmt_update = conn_oracle.createStatement(
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);

			oracle_rs_select = oracle_stmt_select.executeQuery(oracleQueryStr);

			if (!oracle_rs_select.next()) {
				// 无结果集
				// do something.
			} else {
				// 因为经过了 !oracle_rs.next() 语句,指针就不子第一位了,故用下面的方法
				// 有结果集，指针归位
				oracle_rs_select.beforeFirst();
			}

			while (oracle_rs_select.next()) {

				boolean isFind = false;

				STANDARD_CODE = oracle_rs_select.getString("STANDARD_CODE");
				// System.out.println(STANDARD_CODE);

				classCode = StandardCodeUtils
						.getClassCodeFromStandardCode(STANDARD_CODE,);

				class_four_code = StandardCodeUtils
						.getKindFromStandardCode(STANDARD_CODE);

				// System.out.println(classCode);

				for (ArrayList<String> list : classList) {

					// System.out.println("0 : " +list.get(0));
					// System.out.println("1 : " +list.get(1));
					// System.out.println("2 : " +list.get(2));
					// System.out.println("3 : " +list.get(3));

					if (list.get(3).equals(classCode)) {
						isFind = true;

						class_one_code = list.get(1);
						class_two_code = list.get(2);
						class_three_code = list.get(3);

						fileName = StringUtils.replaceChars(STANDARD_CODE, '/',
								'!');
						fileName = StringUtils.replaceChars(fileName, ' ', '~');
						fileName = StringUtils.replaceChars(fileName, '*', '#');
						fileName = fileName + ".PDF";

						// 写死了，只能用来做行标
						text_address = "Work/" + class_two_code + "/"
								+ class_three_code + "/" + fileName;

						String update_str = "update s0903 s set "
								+ "s.class_one_code ='" + class_one_code + "',"
								+ "s.class_two_code='" + class_two_code + "',"
								+ "s.class_three_code='" + class_three_code
								+ "'," + "s.class_four_code='"
								+ class_four_code + "'," + "s.text_address='"
								+ text_address + "',"
								+ "s.lasted_modify_time='2009-03-09',"
								+ "s.lasted_user='蓝标校对数据批量导入' "
								+ "where s.standard_code='" + STANDARD_CODE
								+ "'";

						// System.out.println("update_str : " + update_str);

						// oracle_stmt_update.executeUpdate(update_str);

						oracle_stmt_update.addBatch(update_str);

						countUpdateNumber++;

						// System.out.println("count : " + countUpdateNumber);

						// System.out
						// .println("class_one_code : " + class_one_code);
						// System.out
						// .println("class_two_code : " + class_two_code);
						// System.out.println("class_three_code : "
						// + class_three_code);
						// System.out.println("class_four_code : "
						// + class_four_code);
						// System.out.println("text_address : " + text_address);

						break;
					}
				}

				if (isFind == false) {
					haveNoClassList.add(STANDARD_CODE);
				}
			}

			System.out.println("begin at : " + new Date());
			oracle_stmt_update.executeBatch();
			System.out.println("end at : " + new Date());

			log.info("have no class :" + haveNoClassList.size());

			for (String s : haveNoClassList)
				System.out.println(s);

			log.info("countUpdateNumber: " + countUpdateNumber);

			oracle.closeDB(oracle_stmt_update);
			oracle.closeDB(oracle_rs_select, oracle_stmt_select, conn_oracle);

		} catch (SQLException ex) {
			ex.printStackTrace();
			oracle.closeDB(oracle_stmt_update);
			oracle.closeDB(oracle_rs_select, oracle_stmt_select, conn_oracle);
		}// 结束从 oracle 中查询
	}

	// 根据查询条件，从 oracle 中读取数据，之后入到 mysql 中
	// 本函数，根据 creatChongqing 更改，具体情况请参考 creatChongqing
	// 如果用工具可以直接导入的话，就不要用这个函数
	public void fromOracleToMysql() {

		// oracle_trs
		Connection conn_oracle = null;
		Oracle_std oracle = new Oracle_std();
		conn_oracle = oracle.getConnection(conn_oracle);

		Statement oracle_stmt = null;
		ResultSet oracle_rs = null;

		// mysql
		Connection mysqlConn = null;
		MySQL mysql = new MySQL();
		mysqlConn = mysql.getConnection(mysqlConn);

		Statement mysql_stmt = null;
		ResultSet mysql_select_rs = null;

		int countUpdateNumber = 0;
		int countInsertNumber = 0;

		// 我单位平台中的字段和重庆字段对应情况
		// ID 标准号ID
		long ID = 0; // 对应重庆字段

		// 标准号
		String STANDARD_CODE = "";// 对应重庆字段 a100

		// 标准中文名称
		String NAMECN = "";// 对应重庆字段 a298

		String oracleQueryStr1 = "ID,STANDARD_CODE,NAMECN";

		String oracleQueryStr = "SELECT "
				+ oracleQueryStr1
				+ " FROM st_standard where where t.class_two_code='GB' or t.class_two_code='HB' order by standard_code";
		// + " FROM st_standard where class_one_code='GN' and
		// class_three_code<>'DB'";

		log.info("oracleQueryStr: " + oracleQueryStr);

		// 开始从 oracle 中查询
		try {

			oracle_stmt = conn_oracle.createStatement();

			if (oracle_stmt.execute(oracleQueryStr)) {
				oracle_rs = oracle_stmt.getResultSet();

				mysql_stmt = mysqlConn.createStatement();

				while (oracle_rs.next()) {

					// ID 标准号ID
					ID = oracle_rs.getLong("ID"); // 对应重庆字段

					// 标准号
					STANDARD_CODE = oracle_rs.getString("STANDARD_CODE");// 对应重庆字段
					// a100
					if (STANDARD_CODE != null) {
						if (STANDARD_CODE.equals("")
								|| STANDARD_CODE.equals("null"))
							STANDARD_CODE = null;
						else
							STANDARD_CODE = "'" + STANDARD_CODE + "'";
					}

					// 标准中文名称
					NAMECN = oracle_rs.getString("NAMECN");// 对应重庆字段 a298
					if (NAMECN != null) {
						if (NAMECN.equals("") || NAMECN.equals("null"))
							NAMECN = null;
						else
							NAMECN = "'" + NAMECN + "'";
					}

					// log.info("");

					// 开始在 mysql 中的重庆格式表中寻找，如果记录已经存在，那么做 update 操作，如果不存在，做插入操作

					String mysqlQueryStr = "SELECT STANDARD_CODE FROM pingtai where STANDARD_CODE="
							+ STANDARD_CODE;
					log.info("mysqlQueryStr: " + mysqlQueryStr);

					// mysql 操作开始
					try {

						if (mysql_stmt.execute(mysqlQueryStr)) {
							mysql_select_rs = mysql_stmt.getResultSet();

							if (mysql_select_rs.next()) {// 存在记录，不用 while 循环,
								// .next()
								// 一次，结果集指针已经下移一次

								log.info("in if");
								countUpdateNumber++;

							} else {// 不存在记录，insert

								log.info("in else");

								countInsertNumber++;

								String mysqlInsertStr = "insert into pingtai (STANDARD_CODE,NAMECN) values ("
										+ STANDARD_CODE + "," + NAMECN + ")";

								log.info("mysqlInsertStr: " + mysqlInsertStr);

								mysql_stmt.execute(mysqlInsertStr);

							}

							// while (oracle_rs.next()) {
						}
						log.info("mysql query succeed.");
						// mysql.closeDB(mysql_stmt_insert);
					} catch (SQLException ex) {
						log.info("exception in mysql query action.");
						mysql.closeDB(mysql_select_rs, mysql_stmt, mysqlConn);
					}// mysql 操作结束

				}
				mysql.closeDB(mysql_select_rs, mysql_stmt, mysqlConn);

			}
			log.info("oracle query succeed.");
			log.info("countInsertNumber: " + countInsertNumber);
			log.info("countUpdateNumber: " + countUpdateNumber);
			oracle.closeDB(oracle_rs, oracle_stmt, conn_oracle);
		} catch (SQLException ex) {
			log.info("exception in query action.");
			mysql.closeDB(mysql_select_rs, mysql_stmt, mysqlConn);
			oracle.closeDB(oracle_rs, oracle_stmt, conn_oracle);
		}// 结束从 oracle 中查询
	}

	/*
	 * 根据文件名称，把文件按照标准类别分类 从源文件中删除指定类别的文件(设有开关) 应用此程序之前要备份源文件 sorecefile 源文件目录
	 * del=ture 删除25个行业文件 del=false 删除非25个行业文件
	 * 
	 */

	public void fileClassifyByFilename(File sorecefile, boolean del) {

		// 25 个重点行业代号，为pdf文件名称起始字母。应用此规则的前提是文件名为标准号。对于非标准号的文件，还要和数据库对应合判断。
		String[] industry25 = { "DL", "FZ", "GA", "GX", "HG", "HJ", "JB", "JC",
				"JG", "LS", "LY", "NY", "QB", "QC", "SB", "SC", "SJ", "SL",
				"SN", "SY", "WS", "YB", "YD", "YS", "YY" };

		File[] listRootFiles = sorecefile.listFiles();

		for (int i = 0; i < listRootFiles.length; i++) {

			// 是否包含在25 个行业中
			// 放在循环中，每次循环赋新值
			boolean isindustry25 = false;

			if (listRootFiles[i].isFile()) {// .isDirectory()，有时候，isFile()函数，对于个别文件，判断不准确，不能认出是文件

				fileAllNumber++;

				// 得到指定目录的pdf文件的文件名,并解析成标准号
				// D://pdf/GB!T~123.pdf -> GB!T~123
				File originalFileName = listRootFiles[i];
				// 拷贝用，源路径
				String absolutePathSource = originalFileName.getAbsolutePath();
				String pdfFileBaseName = FilenameUtils
						.getBaseName(originalFileName.getName());
				// log.info("before pdfFileBaseName : " + pdfFileBaseName);

				// 提取标准号，暂时不启用
				// pdfFileBaseName = StringUtils.replaceChars(pdfFileBaseName,
				// '!', '/');
				// pdfFileBaseName = StringUtils.replaceChars(pdfFileBaseName,
				// '~', ' ');
				// log.info("after pdfFileBaseName : " + pdfFileBaseName);

				for (int j = 0; j < industry25.length; j++) {
					if (pdfFileBaseName.startsWith(industry25[j])) {// 文件包含在25个行业中
						isindustry25 = true;
						// log.info("for pdfFileBaseName :"+pdfFileBaseName);
						fileIsindustry25Number++;
						break;
					}
				}

				if (isindustry25 == false)
					fileIsNotindustry25Number++;

				// 删除 25 个行业文件,计算25个行业的文件数量
				if (del == true && isindustry25 == true) {
					try {

						// log.info(originalFileName+" is deleted!");
						delFileIsindustry25Number++;
						continue;
					} catch (Exception e) {// IOException
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}

				// 删除非 25 个行业文件,计算非25个行业的数量
				if (del == false && isindustry25 == false) {
					try {

						// log.info(originalFileName+" is deleted!");
						delFileIsNotindustry25Number++;
						continue;
					} catch (Exception e) {// IOException
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}

				// copy 25
				if (isindustry25 == true) {// 
					try {

						// log.info(originalFileName+" is deleted!");

						// 拷贝到的目标绝对路径
						// 把25个行业的文件按照原来的目录结构，拷贝到另外一个文件夹
						// 001 为原来的文件中包含的路径 ；002 为目标中指定的文件路径
						// 拷贝之后，所有的文件都在 002 的目录下面
						String absolutePathTarget25 = StringUtils.replace(
								absolutePathSource, "test1", "002");
						try {
							FileUtils.copyFile(new File(absolutePathSource),
									new File(absolutePathTarget25), true);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						copyFileIsindustry25Number++;
						continue;
					} catch (Exception e) {// IOException
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}

				// copy 非 25
				if (isindustry25 == false) {// 
					try {

						// log.info(originalFileName+" is deleted!");

						// 拷贝到的目标绝对路径
						// 把25个行业的文件按照原来的目录结构，拷贝到另外一个文件夹
						// 001 为原来的文件中包含的路径 ；003 为目标中指定的文件路径
						// 拷贝之后，所有的文件都在 003 的目录下面
						String absolutePathTarget = StringUtils.replace(
								absolutePathSource, "test1", "003");
						try {
							FileUtils.copyFile(new File(absolutePathSource),
									new File(absolutePathTarget), true);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						copyFileIsindustry25Number++;
						continue;
					} catch (Exception e) {// IOException
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}

			if (listRootFiles[i].isDirectory())// 递归
			{
				directoryNumber++;
				fileClassifyByFilename(listRootFiles[i], del);
			}
		}
	}

	// 把指定文件夹的文件，按照 25 和 非25行业分别拷贝出来，拷贝之后的文件夹结构，和原来的一致
	public void copyFileClassifyByFilename(File sorecefile) {

		// 25 个重点行业代号，为pdf文件名称起始字母。应用此规则的前提是文件名为标准号。对于非标准号的文件，还要和数据库对应合判断。
		// GB 开头的标准，也和 25 行业一起处置

		String[] industry25 = { "GB", "DL", "FZ", "GA", "GX", "HG", "HJ", "JB",
				"JC", "JG", "LS", "LY", "NY", "QB", "QC", "SB", "SC", "SJ",
				"SL", "SN", "SY", "WS", "YB", "YD", "YS", "YY" };

		File[] listRootFiles = sorecefile.listFiles();

		for (int i = 0; i < listRootFiles.length; i++) {

			// 是否包含在25 个行业中
			// 放在循环中，每次循环赋新值
			boolean isindustry25 = false;

			if (listRootFiles[i].isFile()) {// .isDirectory()，有时候，isFile()函数，对于个别文件，判断不准确，不能认出是文件

				fileAllNumber++;

				// 得到指定目录的pdf文件的文件名,并解析成标准号
				// D://pdf/GB!T~123.pdf -> GB!T~123
				File originalFileName = listRootFiles[i];

				// 拷贝用，源路径
				String absolutePathSource = originalFileName.getAbsolutePath();
				String pdfFileBaseName = FilenameUtils
						.getBaseName(originalFileName.getName());
				// log.info("before pdfFileBaseName : " + pdfFileBaseName);

				// 提取标准号，暂时不启用
				// pdfFileBaseName = StringUtils.replaceChars(pdfFileBaseName,
				// '!', '/');
				// pdfFileBaseName = StringUtils.replaceChars(pdfFileBaseName,
				// '~', ' ');
				// log.info("after pdfFileBaseName : " + pdfFileBaseName);

				for (int j = 0; j < industry25.length; j++) {
					if (pdfFileBaseName.startsWith(industry25[j])) {// 文件包含在25个行业中
						isindustry25 = true;
						// log.info("for pdfFileBaseName :"+pdfFileBaseName);
						fileIsindustry25Number++;
						break;
					}
				}

				if (isindustry25 == false)
					fileIsNotindustry25Number++;

				// copy 25
				if (isindustry25 == true) {// 
					try {

						// log.info(originalFileName+" is deleted!");

						// 拷贝到的目标绝对路径
						// 把25个行业的文件按照原来的目录结构，拷贝到另外一个文件夹
						// GB_new 为原来的文件中包含的路径 ；is25 为目标中指定的文件路径
						// 拷贝之后，所有的25行业文件都在 is25 的目录下面
						String absolutePathTarget25 = StringUtils.replace(
								absolutePathSource, "GB_new", "is25");
						try {
							FileUtils.copyFile(new File(absolutePathSource),
									new File(absolutePathTarget25), true);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						copyFileIsindustry25Number++;
						continue;
					} catch (Exception e) {// IOException
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}

				// copy 非 25
				if (isindustry25 == false) {// 
					try {

						// log.info(originalFileName+" is deleted!");

						// 拷贝到的目标绝对路径
						// 把25个行业的文件按照原来的目录结构，拷贝到另外一个文件夹
						// GB_new 为原来的文件中包含的路径 ；isnot25 为目标中指定的文件路径
						// 拷贝之后，所有的非25行业文件都在 isnot25 的目录下面
						String absolutePathTarget = StringUtils.replace(
								absolutePathSource, "GB_new", "isnot25");
						try {
							FileUtils.copyFile(new File(absolutePathSource),
									new File(absolutePathTarget), true);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						copyFileIsNotindustry25Number++;
						continue;
					} catch (Exception e) {// IOException
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			if (listRootFiles[i].isDirectory())// 递归
			{
				directoryNumber++;
				copyFileClassifyByFilename(listRootFiles[i]);
			}
		}
	}

	/**
	 * 把指定文件夹内的文件，按照指定日期范围内，拷贝到指定文件夹中,包含 DateBegin，DateEnd 两天
	 * 
	 * @param srcDir 源文件夹
	 * @param desDir 目标文件夹
	 * @param DateBegin 开始日期
	 * @param DateEnd 截止日期
	 */

	// 拷贝到目标文件夹的文件数目，可能与源文件夹的文件数目不一致
	// 源文件夹中的文件是分布在不同的文件夹中的，所以如有重复的文件
	// 拷贝到一个文件夹中之后，重复的文件会相互覆盖。
	public void copyFilefyByDateRange(File srcDir, File desDir, int DateBegin,
			int DateEnd) {

		// 目标文件是否存在，不存在则创建
		try {
			MyFileUtils.makeDir(desDir.getAbsolutePath());
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		int copyCount = 0;
		// 源目录必须为校对专用目录，因为下面要拆分目录名称，组成文件路径
		File[] listRootFiles = srcDir.listFiles();// 得到F:\\server\\is25\\

		// 得到F:\\server\\is25\\00\\
		for (int i = 0; i < listRootFiles.length; i++) {// for1
			File[] listUseridFiles = listRootFiles[i].listFiles();
			// 得到 F:\\server\\is25\\20070101
			for (int j = 0; j < listUseridFiles.length; j++) { // for2
				// 取得文件的绝对路径名称
				String absolutePathSource = listUseridFiles[j]
						.getAbsolutePath();

				// 解析出来当前的文件夹名称
				String Drictory = StringUtils.substringAfterLast(
						absolutePathSource, "\\");

				int d = Integer.parseInt(Drictory);

				// 输入不合法，略过
				if (DateBegin > DateEnd)
					return;

				// 不在指定的日期范围内，略过
				if (DateBegin > d || d > DateEnd) {
					// log.info(absolutePathSource + " is not in range");
					continue;
				}

				log.info("begain copy " + listUseridFiles[j].getAbsolutePath());

				// 得到文件夹中的文件
				File[] listPDFFiles = listUseridFiles[j].listFiles();

				for (int p = 0; p < listPDFFiles.length; p++) {// for2 得到
					// K:\is25\00\20070701\GB~124-2005.pdf
					try {
						FileUtils.copyFileToDirectory(listPDFFiles[p], desDir);
						copyCount++;
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

				}
			}
		}
		log.info(copyCount + " files copied.");
	}

	// 指定文件夹中的文件，根据名称解析出标准类别，分别拷贝到相应的以类别命名的文件夹中
	public void copyFilefyByClassifyFileName() {

		// D:\ftpFiles\2008-11-26-02.50.18
		// String fileSource = "F:\\copy_old\\";
		String fileSource = "F:\\copyis25\\HB\\";
		String copyTo = "F:\\copyis25_new\\";
		int count = 0;

		// 平台中，GB 目录存放的标准类别
		// String[] GB = { "GB", "GBJ", "GBN", "GBZ", "GJB", "JJF", "JJG" };

		ArrayList<String> al = new ArrayList<String>();
		// File outTXT = new File("D:\\std_s.txt");

		File[] listRootFiles = new File(fileSource).listFiles();

		for (int i = 0; i < listRootFiles.length; i++) {

			File fileS = listRootFiles[i];// 得到F:\\copy_old\\GB~12345.pdf
			String fileName = fileS.getName();

			char[] cname = fileName.toCharArray();
			int pend = 0;
			for (int j = 0; j < cname.length; j++)// 找到第一个非字母的位置
			{
				if (!CharUtils.isAsciiAlpha(cname[j])) {
					pend = j;
					break;
				}
			}

			String directoryTo = StringUtils.substring(fileName, 0, pend);

			directoryTo = copyTo + directoryTo;

			log.info("fileName :" + fileName);
			log.info("directoryTo :" + directoryTo);

			File d = new File(directoryTo);

			try {
				// This method copies the contents of the specified source file
				// to a
				// file of the same name in the specified destination directory.
				// The
				// destination directory is created if it does not exist. If the
				// destination file exists, then this method will overwrite it.

				FileUtils.copyFileToDirectory(fileS, d);
				count++;

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

		log.info(count + " files copied");

	}

	// 根据标准号，确定其三级分类，分别拷贝到相应的以三级分类命名的文件夹中
	public void copyFilefyByClassByStandardCode() {

		// D:\ftpFiles\2008-11-26-02.50.18
		// String fileSource = "F:\\copy_old\\";
		String srcDir = "K:\\copyis25ByDateRange\\";
		String destDir = "H:\\class\\";
		int count = 0;

		// oracle_standard
		Connection conn_oracle = null;
		Oracle_std oracle = new Oracle_std();
		conn_oracle = oracle.getConnection(conn_oracle);
		Statement oracle_stmt_select = null;
		ResultSet oracle_rs_select = null;

		String oracleQueryStr = "select standard_code,class_three_code,text_address from insert433 where lasted_user='蓝标校对数据批量导入'";

		log.info("oracleQueryStr :" + oracleQueryStr);

		// File srcDir, File destDir
		String srcFile = "";
		String destFile = "";

		String STANDARD_CODE = "";
		String class_three_code = "";
		String text_address = "";
		String fileName = "";

		System.out.println("begin at : " + new Date());

		// 开始从待完善的表中查询需要完善的题录信息
		try {

			// oracle_stmt = oracle_conn.createStatement();
			// 为了支持 oracle_rs.beforeFirst() 方法，createStatement 带了参数
			// 否则 oracle_stmt = oracle_conn.createStatement() 即可

			oracle_stmt_select = conn_oracle.createStatement(
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);

			oracle_rs_select = oracle_stmt_select.executeQuery(oracleQueryStr);

			if (!oracle_rs_select.next()) {
				// 无结果集
				// do something.
			} else {
				// 因为经过了 !oracle_rs.next() 语句,指针就不子第一位了,故用下面的方法
				// 有结果集，指针归位
				oracle_rs_select.beforeFirst();
			}

			while (oracle_rs_select.next()) {

				boolean isFind = false;

				STANDARD_CODE = oracle_rs_select.getString("STANDARD_CODE");
				class_three_code = oracle_rs_select
						.getString("class_three_code");

				if (class_three_code.equals("CB*"))
					class_three_code = "CB";

				text_address = oracle_rs_select.getString("text_address");
				//
				fileName = StringUtils.substringAfterLast(text_address, "/");

				srcFile = srcDir + fileName;
				destFile = destDir + class_three_code + "\\" + fileName;

				log.info("srcFile :" + srcFile);
				log.info("destFile :" + destFile);

				try {
					FileUtils.copyFile(new File(srcFile), new File(destFile));
					count++;
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

			System.out.println("end at : " + new Date());

			log.info(count + " files copied");

			oracle.closeDB(oracle_rs_select, oracle_stmt_select, conn_oracle);

		} catch (SQLException ex) {
			ex.printStackTrace();
			oracle.closeDB(oracle_rs_select, oracle_stmt_select, conn_oracle);
		}// 结束从 oracle 中查询

	}

	// 根据文件中的准号，拷贝指定文件夹中的文件
	// 根据名称解析出标准类别，分别拷贝到相应的以类别命名的文件夹中
	public void copyFilefyByStandardName() {

		// D:\ftpFiles\2008-11-26-02.50.18
		// String fileSource = "F:\\copy_old\\";
		String standardFileSource = "D:\\20090225\\temp.txt";
		String fileSource = "F:\\copyis25ByDateRange\\";
		String copyTo = "F:\\copyis25_new_25\\";
		File copyToDirectory = new File(copyTo);

		int count = 0;

		List<String> std = null;
		try {
			std = FileUtils.readLines(new File(standardFileSource));
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		String pdfName = "";

		for (String s : std) {

			// 提取标准号

			pdfName = StringUtils.replaceChars(s, '/', '!');
			pdfName = StringUtils.replaceChars(pdfName, ' ', '~');
			pdfName = StringUtils.replaceChars(pdfName, '*', '#');
			pdfName = pdfName + ".pdf";

			File temp = new File(fileSource + pdfName);

			if (temp.exists()) {

				try {
					log.info("copy " + temp);
					FileUtils.copyFileToDirectory(temp, copyToDirectory);
					count++;
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

			else {

				log.info("file " + pdfName + " not exist!");
			}

		}

		log.info(count + " files copied");

	}

	// 根据文件中的准号，移动文件到指定文件夹
	// 
	public void moveFileToDirectoryByStandardName() {

		// D:\ftpFiles\2008-11-26-02.50.18
		// String fileSource = "F:\\copy_old\\";
		String standardFileSource = "D:\\20090225\\move.txt";
		String fileSource = "F:\\copyis25ByDateRange\\";
		String moveTo = "F:\\is25_move\\";
		File destDir = new File(moveTo);

		int count = 0;

		List<String> std = null;
		try {
			std = FileUtils.readLines(new File(standardFileSource));
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		String pdfFileName = "";

		for (String s : std) {

			// 提取标准号

			pdfFileName = StringUtils.replaceChars(s, '/', '!');
			pdfFileName = StringUtils.replaceChars(pdfFileName, ' ', '~');
			pdfFileName = StringUtils.replaceChars(pdfFileName, '*', '#');
			pdfFileName = pdfFileName + ".pdf";

			File srcFile = new File(fileSource + pdfFileName);

			if (srcFile.exists()) {

				try {
					log.info("move " + srcFile);
					FileUtils.moveFileToDirectory(srcFile, destDir, true);
					// FileUtils.copyFileToDirectory(srcFile, destDir);
					count++;
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

			else {

				log.info("file " + pdfFileName + " not exist!");
			}

		}

		log.info(count + " files copied");

	}

	/**
	 * 删除指定文件夹下面的，指定日期范围的文件
	 * 
	 * @param srcDir
	 *            指定文件夹
	 * @param Datebefore
	 *            其实日期
	 * @param Dateend
	 *            结束日期
	 */

	// 减少校对文件夹的大小
	// 删除指定日期范围的文件，包含两个时间点
	// 运行此函数之前，先运行 copyFilefyByDateRange()，拷贝之后，再删除，并且要比较拷贝数目和删除数目是否相同防止误删除.
	// 做一个完整的备份
	public void delFilefyByDateRange(File srcDir, int Datebefore, int Dateend) {

		// srcDir 应该到这一级 F:\\server\\is25\\
		File[] userid = srcDir.listFiles();

		int count = 0;

		// F:\\server\\is25\\000\\ 得到每个用户的id目录
		for (int i = 0; i < userid.length; i++) {
			// 每个人 id 下面即为日期
			File[] dateDirectory = userid[i].listFiles();

			// F:\\server\\is25\\000\\20070101 得到每个用户的id目录下面的日期文件夹
			for (int j = 0; j < dateDirectory.length; j++) {
				// 比较日期，开始删除
				// 取得文件的绝对路径名称
				String absolutePathSource = dateDirectory[j].getAbsolutePath();
				// log.info("for2:" + absolutePathSource);
				// 解析出来当前的文件夹名称
				String Drictory = StringUtils.substringAfterLast(
						absolutePathSource, "\\");

				// log.info("Drictory :" + Drictory);
				// int d = new Integer(Drictory).intValue();
				int d = Integer.parseInt(Drictory);
				// log.info("d:" + d);

				// 输入不合法，略过
				if (Datebefore > Dateend)
					return;

				// 不在指定的日期范围内，略过
				if (Datebefore > d || d > Dateend) {
					// log.info(absolutePathSource + " is not in range");
					continue;
				}
				System.out.println(dateDirectory[j].getAbsolutePath());
				// 开始删除
				// try {
				// FileUtils.deleteDirectory(dateDirectory[j]);
				// count++;
				// log.info("delete directory " + dateDirectory[j]
				// + " succeed.");
				// } catch (IOException e) {
				// // TODO Auto-generated catch block
				// e.printStackTrace();
				// }
			}
		}
		log.info(count + " directories are delected.");
	}

	/*
	 * 根据文件名称，查找标准号和标准名称 只用来提取损害的文件
	 * 
	 */

	public void findStdcodeByBadFilename() {

		String pdfFileRoot = "F:/server/GB_exception/";
		String excelFileRoot = "D:/badfiles.xls";

		File pdfDirRoot = new File(pdfFileRoot);
		File excelDirRoot = new File(excelFileRoot);

		WritableWorkbook wwb = null;

		int fileCount = 0;

		// 建立文件
		try {
			// 首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象
			wwb = Workbook.createWorkbook(excelDirRoot);
		} catch (IOException e) {
			System.out.println("exception 0.");
			eu.closeWritableWorkbook(wwb);
			e.printStackTrace();

		}
		if (wwb == null)
			return;

		// 开始操作excel表
		// 创建一个可写入的工作表
		// Workbook的createSheet方法有两个参数，第一个是工作表的名称，第二个是工作表在工作薄中的位置
		WritableSheet ws = wwb.createSheet("sheet1", 0);

		Connection conn = null;
		Oracle_trs oracle = new Oracle_trs();
		conn = oracle.getConnection(conn);

		// int count = 0;
		// Map<String, Integer> mp = new TreeMap<String, Integer>();

		File[] listRootFiles = pdfDirRoot.listFiles();

		for (int i = 0; i < listRootFiles.length; i++) {

			if (listRootFiles[i].isDirectory())
				continue;

			fileCount++;

			// 得到指定目录的pdf文件的文件名,并解析成标准号
			// D://pdf/GB!T~123.pdf -> GB!T~123.pdf
			String pdfFileName = FilenameUtils.getName(listRootFiles[i]
					.getName());// 得到 GB!T~123.pdf
			log.info("before pdfFileName : " + pdfFileName);
			if (pdfFileName.startsWith("GB"))
				pdfFileName = "Work/GB/" + pdfFileName;
			else if (pdfFileName.startsWith("DB"))
				pdfFileName = "Work/DB/" + pdfFileName;
			else
				pdfFileName = "Work/HB/" + pdfFileName;

			log.info("after pdfFileName : " + pdfFileName);

			// ===============================================
			// 连接到 oracle 开始查询

			String oracleQueryStr = "select t.standard_code,t.namecn  from trstable t where t.text_address='"
					+ pdfFileName + "'";
			log.info("oracleQueryStr :" + oracleQueryStr);

			Statement stmt_oracleQuery = null;
			ResultSet rs_oracleQuery = null;

			try {

				stmt_oracleQuery = conn.createStatement();
				String oracle_stdcode = "";
				String oracle_std_namecn = "";

				if (stmt_oracleQuery.execute(oracleQueryStr)) {
					rs_oracleQuery = stmt_oracleQuery.getResultSet();

					while (rs_oracleQuery.next()) {

						oracle_stdcode = (String) rs_oracleQuery
								.getString("standard_code");
						oracle_std_namecn = (String) rs_oracleQuery
								.getString("namecn");

					}
				}

				Label label0 = new Label(0, i, new java.lang.Integer(i + 1)
						.toString());

				Label label1 = new Label(1, i, pdfFileName);
				Label label2 = new Label(2, i, oracle_stdcode);
				Label label3 = new Label(3, i, oracle_std_namecn);

				// 行数增加
				try {
					// 将生成的单元格添加到工作表中
					ws.addCell(label0);
					ws.addCell(label1);
					ws.addCell(label2);
					ws.addCell(label3);
				} catch (RowsExceededException e) {
					System.out.println("exception 2.");
					e.printStackTrace();
					// 发生异常关闭
					eu.closeWritableWorkbook(wwb);
				} catch (WriteException e) {
					System.out.println("exception 3.");
					e.printStackTrace();
					// 发生异常关闭
					eu.closeWritableWorkbook(wwb);
				}

			} catch (SQLException ex) {
				log.info("exception in query action.");
				oracle.closeDB(rs_oracleQuery, stmt_oracleQuery, conn);
			}

			oracle.closeDB(rs_oracleQuery, stmt_oracleQuery);

		} // 开始第二个文件比对

		oracle.closeDB(conn);
		log.info("fileCount is: " + fileCount);

		// 从内存中写入文件中
		try {
			wwb.write();
			wwb.close();
		} catch (WriteException e) {
			// TODO Auto-generated catch block
			System.out.println("exception 4.");
			e.printStackTrace();
		} catch (IOException e) {
			System.out.println("exception 5.");
			e.printStackTrace();
		}
	}

	// 此函数只用来提取蓝标校对完成的文件
	// 提取把指定文件夹内文件的文件名，按照指定日期范围内，标注到数据库中
	// 去掉重复的标准号_还没有做????

	// 包含 Datebefore，Dateend 两天

	public void findStdcodeByfileName(int Datebefore, int Dateend) {

		Oracle_trs oracle = new Oracle_trs();
		Connection oracle_conn = null;
		Statement oracle_stmt = null;

		String delete_filenametemp = "delete filenametemp";
		log.info("delete filenametemp:" + delete_filenametemp);

		int inserCount = 0;

		try {
			oracle_conn = oracle.getConnection(oracle_conn);
			oracle_stmt = oracle_conn.createStatement();
			oracle_stmt.executeUpdate(delete_filenametemp);

		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 必须指定类似的目录，因为下面要拆分目录名称
		File[] listRootFiles = new File("K:\\is25\\").listFiles();// K:\is25\

		for (int i = 0; i < listRootFiles.length; i++) {// for1

			// log.info("for1:" + listUseridFileName.getAbsolutePath());

			File[] listCheckDateFiles = listRootFiles[i].listFiles();// // 得到
			// K:\is25\00\

			for (int j = 0; j < listCheckDateFiles.length; j++) { // for2
				// K:\is25\00\20070701

				// 取得文件的绝对路径名称
				String checkDateAb = listCheckDateFiles[j].getAbsolutePath();

				// log.info("for2:" + checkDateAb);

				// 解析出来当前的文件夹名称
				String checkDate = StringUtils.substringAfterLast(checkDateAb,
						"\\");

				// log.info("Drictory :" + checkDate);

				// int d = new Integer(Drictory).intValue();
				int d = Integer.parseInt(checkDate);

				// log.info("d:" + d);

				// 不在指定的日期范围内，略过

				if (Datebefore > Dateend)
					return;

				if (Datebefore > d || d > Dateend) {
					log.info(checkDateAb + " is not in range");
					continue;
				}

				File[] listPDFFiles = listCheckDateFiles[j].listFiles();

				log.info("insert :" + checkDateAb);

				for (int p = 0; p < listPDFFiles.length; p++) {

					inserCount++;

					String pdfName = listPDFFiles[p].getName();

					// 提取标准号
					pdfName = StringUtils.replace(pdfName, ".pdf", "");
					pdfName = StringUtils.replace(pdfName, ".PDF", "");
					pdfName = StringUtils.replaceChars(pdfName, '!', '/');
					pdfName = StringUtils.replaceChars(pdfName, '~', ' ');
					// log.info("StdCode is: " + pdfName);

					// insert to oracle trs

					if (pdfName.equals("HG/T 1549.3-1995"))
						log.info("hello:" + listPDFFiles[p].getAbsolutePath());

					String insert = "insert into filenametemp (id,stdcode) values ("
							+ inserCount + ",'" + pdfName + "')";

					// log.info("insert:" + insert);

					try {
						oracle_stmt.executeUpdate(insert);
						// log.info("executeUpdate succeed.");
					} catch (SQLException ex) {
						log.info("exception in executeUpdate action.");
						ex.printStackTrace();
						oracle.closeDB(oracle_stmt, oracle_conn);
					}

				}
			}
		}

		oracle.closeDB(oracle_stmt, oracle_conn);
	}

/**
 * 提取把指定文件夹内文件的文件名，生成文件，源目录仅有一级
 * @param srcDir 待提取的文件所在的文件夹
 * @param txtFile 生成的结果 
 */
	public void findStdcodeByfileName(File srcDir,File txtFile) {

		// 只有一级目录，里面的文件均按照标准号命名
		File[] listRootFiles = srcDir.listFiles();		
		ArrayList<String> resultList = new ArrayList<String>();
		int length = listRootFiles.length;
		for (int i = 0; i < length; i++) {// 进入第一级文件夹

			String pdfName = listRootFiles[i].getName();

			System.out.println(pdfName);

			// 提取标准号
			pdfName = StringUtils.replace(pdfName, ".pdf", "");
			pdfName = StringUtils.replace(pdfName, ".PDF", "");
			// pdfName = StringUtils.replace(pdfName, ".PDF", "");
			pdfName = StringUtils.replaceChars(pdfName, '!', '/');
			pdfName = StringUtils.replaceChars(pdfName, '~', ' ');
			pdfName = StringUtils.replaceChars(pdfName, '#', '*');// 专门针对一批 CB
			// 标准
			// log.info("StdCode is: " + pdfName);
			resultList.add(pdfName);
		}

		try {
			FileUtils.writeLines(txtFile, resultList);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		log.info(resultList.size() + " standard names are collected");
	}


	// 清理数据专用
	// 把指定文件夹的文件，按照标准号重新命名
	// 需要知道校对人和校对时间，数据库表设计为 odbc_import_pici2 样式
	// 本函数只能执行一次，执行之后，手工改写 .bak 文件;不要用用程序修改 .bak 文件，可能还会有重名问题
	// k:\ rename\000 *.pdfbak *.pdf

	public void renameFilefyByStdcode() {

		String rootDirectory = "K:\\is25\\";
		String renameDirectory = "K:\\rename\\";

		Statement oracle_stmt = null;
		ResultSet oracle_rs = null;
		Connection oracle_conn = null;
		Oracle_trs oracle = new Oracle_trs();

		File f1 = null;
		File f2 = null;
		File fExist = null;

		int count = 0;
		int countExist = 0;
		String query = "select t.stdcode,t.stdcodenew,t.userid,t.checkdate,t.statea from odbc_import_pici3 t where t.statea is null";

		oracle_conn = oracle.getConnection(oracle_conn);

		try {

			// 为了支持 oracle_rs.beforeFirst() 方法，createStatement 带了参数
			oracle_stmt = oracle_conn.createStatement(
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);
			oracle_rs = oracle_stmt.executeQuery(query);

			while (oracle_rs.next()) {

				String stdcode = (String) oracle_rs.getString("stdcode");
				// log.info("stdcode: "+stdcode);
				String stdcodenew = (String) oracle_rs.getString("stdcodenew");
				String userid = (String) oracle_rs.getString("userid");
				String checkdate = (String) oracle_rs.getString("checkdate");

				String fileNameSource = StringUtils.replaceChars(stdcode, '/',
						'!');
				fileNameSource = StringUtils.replaceChars(fileNameSource, ' ',
						'~');

				String fileNameTarget = StringUtils.replaceChars(stdcodenew,
						'/', '!');
				fileNameTarget = StringUtils.replaceChars(fileNameTarget, ' ',
						'~');

				fileNameSource = rootDirectory + userid + "\\" + checkdate
						+ "\\" + fileNameSource + ".pdf";
				fileNameTarget = rootDirectory + userid + "\\" + checkdate
						+ "\\" + fileNameTarget + ".pdf";

				String fileNameExist = fileNameTarget + "bak";

				// log.info("fileNameSource:" + fileNameSource);
				// log.info("fileNameTarget:" + fileNameTarget);
				// log.info("stdcode:" + stdcode);
				// log.info("fileNameSource:"+fileNameSource);
				// log.info("stdcodenew:" + stdcodenew);
				// log.info("fileNameTarget:"+fileNameTarget);

				f1 = new File(fileNameSource);
				f2 = new File(fileNameTarget);
				fExist = new File(fileNameExist);
				// log.info("file name:"+f1.getName());

				if (!f1.exists()) {
					// log.info("fileSource is not exist:" +
					// f1.getAbsolutePath());
					continue;
				}

				try {

					// 拷贝文件
					FileUtils.copyFile(f1, new File(renameDirectory
							+ f1.getName()), true);

					// 剪切文件
					// FileUtils.moveFile(f1, new File(renameDirectory
					// + f1.getName()));

					log.info(renameDirectory + f1.getAbsolutePath()
							+ " move to rename directory.");
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

			// begin to rename
			// 指针移到最前面
			// oracle_rs.first();
			oracle_rs.beforeFirst();

			while (oracle_rs.next()) {

				String stdcode = (String) oracle_rs.getString("stdcode");
				// log.info("stdcode: "+stdcode);
				String stdcodenew = (String) oracle_rs.getString("stdcodenew");

				// fileNameSource
				String fileNameSource = StringUtils.replaceChars(stdcode, '/',
						'!');
				fileNameSource = StringUtils.replaceChars(fileNameSource, ' ',
						'~');

				// fileNameTarget
				String fileNameTarget = StringUtils.replaceChars(stdcodenew,
						'/', '!');
				fileNameTarget = StringUtils.replaceChars(fileNameTarget, ' ',
						'~');

				fileNameSource = renameDirectory + "\\" + fileNameSource
						+ ".pdf";
				fileNameTarget = renameDirectory + "\\" + fileNameTarget
						+ ".pdf";

				String fileNameExist = fileNameTarget + "bak";

				// log.info("fileNameSource:" + fileNameSource);
				// log.info("fileNameTarget:" + fileNameTarget);
				// log.info("stdcode:" + stdcode);
				// log.info("fileNameSource:"+fileNameSource);
				// log.info("stdcodenew:" + stdcodenew);
				// log.info("fileNameTarget:"+fileNameTarget);

				f1 = new File(fileNameSource);
				f2 = new File(fileNameTarget);
				fExist = new File(fileNameExist);
				// log.info("file name:"+f1.getName());

				if (!f1.exists()) {
					log.info("fileSource is not exist:" + f1.getAbsolutePath());
					continue;
				}

				if (f2.exists()) {// 临时重命名
					countExist++;
					f1.renameTo(fExist);
					log.info("rename " + f1.getAbsolutePath() + " to "
							+ fExist.getAbsoluteFile());
				} else {
					count++;
					f1.renameTo(f2);
					log.info("rename " + f1.getAbsolutePath() + " to "
							+ f2.getAbsoluteFile());
				}
			}

			log.info("rename files:" + count);
			log.info("rename exist files:" + countExist);

			oracle.closeDB(oracle_rs, oracle_stmt, oracle_conn);

		} catch (SQLException ex) {
			ex.printStackTrace();
			log.info("exception in query action.");
			oracle.closeDB(oracle_rs, oracle_stmt, oracle_conn);
		}

	}

	// 由于使用了递归,所以要放在类变量处
	// 递归函数,如果文件过多,会消耗非常大的内存
	ArrayList<String> al = new ArrayList();

	public void find(File sorecefile) {
		File[] listRootFiles = sorecefile.listFiles();
		int leng = listRootFiles.length;

		ExcelUtils eu = new ExcelUtils();

		int id = 0;
		String fileName = "";

		for (int i = 0; i < leng; i++) {
			if (listRootFiles[i].isFile()) {// .isDirectory()，有时候，isFile()函数，对于个别文件，判断不准确，不能认出是文件
				fileName = listRootFiles[i].getName();
				al.add(fileName);
				log.info("file name :" + fileName);
				// log.info("al.size() :" + al.size());
			} else if (listRootFiles[i].isDirectory()) {
				find(listRootFiles[i]);
			} else {
				log.info("file error :" + fileName);
				continue;
			}
		}
		eu.writeArrayListStringValueToExcel(new File("D:\\0byte.xls"), al);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		FileUtil fu = new FileUtil();
		String HB = "HB";
		String DB = "DB";
		String GB = "GB";

		// fu.updatelonelyPDFfile(GB);
		// String filepath = "D:/updatelonelyPDFfile_old_hb.xls";
		// fu.count(filepath);

		// fu.findStdcodeByFilename();

		// fu.updateShenzhenPDFfile();
		// fu.modShenzhen_btdbz();
		// fu.creatChongqing();
		// fu.fromOracleToMysql();

		// String userid[] = { "000", "001", "002", "003", "004", "005", "006",
		// "007", "10", "11", "15", "16", "17", "20", "21", "22", "23",
		// "24", "25", "26", "27" };
		//
		// for (int i = 0; i < userid.length; i++) {
		// fu.copyFilefyByDateRange(new File("K:\\is25\\" + userid[i]),
		// 20070610, 20070914);
		// }
		//
		// System.out.println("文件总数是：" + fu.fileAllNumber);
		// System.out.println("文件夹总数是：" + fu.directoryNumber);
		// System.out.println("25 个行业文件总数是：" + fu.fileIsindustry25Number);
		// System.out.println("非25 个行业文件总数是：" + fu.fileIsNotindustry25Number);
		// System.out.println("共计删除 25 个行业文件总数是：" +
		// fu.delFileIsindustry25Number);
		// System.out.println("共计删除 25 个行业文件总数是："
		// + fu.delFileIsNotindustry25Number);
		//
		// System.out.println("拷贝 25 个行业文件总数是：" +
		// fu.copyFileIsindustry25Number);
		// System.out.println("拷贝非 25 个行业文件总数是："
		// + fu.copyFileIsNotindustry25Number);

		// fu.delFilefyByDateRange("K:\\is25\\", 20070601, 20071231);

		// fu.delFilefyByDateRange("K:\\is25\\", 20070701, 20071231);

		// String s = "test.pdf.bak";
		// System.out.println(StringUtils.removeEnd(s, ".bak"));
		// fu.renameFilefyByStdcode();

		// fu.findStdcodeByfileName();

		// fu.findStdcodeByfileName(20070915, 20071231);

		// fu.copyFilefyByDateRange(20070915,20071231);
		// fu.find(new File("D:\\download\\0k"));
		// fu.find(new File("D:\\123"));

		// 完善校对后的题录信息
		// fu.updateJiaoduiTiLu();
		
		
		// 删除指定文件夹中的目录
		//fu.delFilefyByDateRange(new File("F:\\server\\is25\\"),20050101, 20091231);

		// 按照日期拷贝文件
		//fu.copyFilefyByDateRange(new File("F:\\server\\is25\\"),new File("F:\\server\\is25\\"),20060101, 20090109);

		// 把文件按照分类组织好
		// fu.copyFilefyByClassifyFileName();

		// 根据文件名称提取标准号
		// fu.findStdcodeByfileName();

		// 根据文件中的标准号，拷贝文件
		// fu.copyFilefyByStandardName();

		// 根据标准号移动文件
		// fu.moveFileToDirectoryByStandardName();

		// 根据已经整理好的题录，为文件分类
		// fu.copyFilefyByClassByStandardCode();

	}
}